package com.lxf.Controller;

import com.lxf.pojo.Product;
import com.lxf.pojo.R;
import com.lxf.pojo.User;
import com.lxf.service.ProductService;
import com.lxf.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@RestController
@CrossOrigin
@RequestMapping("/products")
public class ProductController {

    @Autowired
    private ProductService productService;

    @Autowired
    private UserService userService;



    //商品排序
    @PostMapping()
    public R Findquery(@RequestBody Product product){
        List<Product> list=productService.Findquery(product);
        if(list.size()>0){
            return R.ok().date("list",list).errorMsg("展示成功");
        }else{
            return R.error();
        }
    }
    //    商品展示
    @PostMapping("/listAlls")
    public R listAlls(@RequestBody Product product){
        Map map=new HashMap();
        //图片信息
        List<Product> Imgs=productService.Image(product);
        //商品图片
        map.put("Imgs",Imgs);
        //商品详细分类
        List<Product> modelDetails=productService.shopModel(product);
        String[][] array = new String[modelDetails.size()+1][];
        //将大分类放到数组中的第一个
        array[0]=new String[modelDetails.size()];
        for(int i=0;i<modelDetails.size();i++){
            array[0][i]=modelDetails.get(i).getProductModel();
            //获得小分类
            List<Product> list=productService.shopModelInfo(product.getId(),modelDetails.get(i).getProductModel());
            //具体商品下的详细分类放到数组中
            array[i+1]=new String[list.size()];
            for(int j=0;j<list.size();j++){
                array[i+1][j]=list.get(j).getModelDetails();
            }
        }
        if(product.getModelDetails()==null||product.getModelDetails().equals("")){
            product.setModelDetails(array[1][0]);
        }



        Product p=productService.listAlls(product);
        //商品详情信息
        map.put("product",p);

        //详细分类选项
        map.put("array",array);
        Product foots=productService.userFootIsFlag(product.getUserId(), product.getId());
        if(foots!=null){//存在,修改足迹时间为现在
            int footad=productService.updateUserFoot(foots.getId());
        }else{
            //不存在，新增足迹
            int footad=userService.AddFoot(product.getId(),product.getUserId());
        }

        Product pd=productService.isCollect(product.getId(),product.getUserId());
        //判断用户是否收藏该商品
        boolean isCollect=false;
        if(pd!=null){
            isCollect=true;
        }
        map.put("isCollect",isCollect);
        return R.ok().date(map);
    }

    //展示用户足迹
    @GetMapping("/{id}")
    public R UserFoot (@PathVariable int id){
        List<Product> data = productService.UserFoot(id);
        if (data.size()>0) {
            return R.ok().date("data", data).errorMsg("查询足迹成功").success(true);
        } else {
            return R.error();
        }
    }

    /*商品分类*/
    @PostMapping("/Classify")
    public R Classify(@RequestBody Product p){
        Map map=new HashMap();
        List<Product> classify=productService.Classify();
        List<Product> smallClassify=productService.smallClassify(classify);
        map.put("classify",classify);
        map.put("smallClassify",smallClassify);
        return R.ok().date("map",map);
    }

    //
    @PostMapping("/ProductId")
    public R ProductId (@RequestBody Product p){
        List<Product> data = productService.productId(p);
        if (data.size()>0) {
            return R.ok().date("data", data).errorMsg("查询成功").success(true);
        } else {
            return R.error().errorMsg("查询失败");
        }
    }


    @PostMapping("/productClassify")
    public R productClassify(){
        Map map=new HashMap();
        /*
         * 大分类
         * */
        List<Product> p=productService.productClassify();
        map.put("productClassify",p);
        /*
        大分类下对应的小分类
        */
        ArrayList test = new ArrayList();
        for (int i=0;i<p.size();i++){
            List<Product> products=productService.productClassifyInfo(p.get(i).getId());
            String names=p.get(i).getName();
            String[] productClassifyInfo=new String[products.size()];
            for(int j=0;j<products.size();j++){
                productClassifyInfo[j]=products.get(j).getCategoryName();
//              大分类下的小分类分开放
//                map.put(names,productClassifyInfo);
            }
//            大分类下的小分类放在一个数组
            test.add(productClassifyInfo);
            map.put("productClassifyInfo",test);

        }
        return R.ok().date(map);
    }
    //展示收藏
    @PostMapping("/LookCollect/{id}")
    public R LookCollect(@PathVariable int id){
        List<Product> data=productService.LookCollect(id);
        if(data.size()>0){
            return R.ok().date("data",data).errorMsg("查询收藏成功").success(true);
        }else{
            return R.error().errorMsg("查询收藏失败");
        }
    }

    //订单查询
    @PostMapping("/LookOrder/{id}/{orderStatus}")
    public R LookOrder (@PathVariable int id,@PathVariable int orderStatus){
        List<Product> data= productService.LookOrder(id,orderStatus);
        if (data.size()>0) {
            return R.ok().date("data",data).errorMsg("查询订单成功").success(true);
        } else {
            return R.error().errorMsg("查询订单失败");
        }
    }


    //展示购物车
    @PostMapping("/LookShopCar/{userId}")
    public R LookShopCar (@PathVariable int userId){
        List<Product> data= productService.LookShopCar(userId);
        if (data.size()>0) {
            return R.ok().date("data",data).errorMsg("查询购物车成功").success(true);
        } else {
            return R.error().errorMsg("查询购物车失败");
        }
    }

    //删除用户购物车（同时删除多个）
    @DeleteMapping("/delShopCar")
    public R delShopCar(@RequestBody int[] ids){
        boolean flag=true;
        for(int i=0;i<ids.length;i++){
            boolean flags=productService.delShopCar(ids[i]);
            if(!flags){
                flag=false;
                break;
            }
        }
        if(flag){
            return R.ok().errorMsg("删除成功!").success(true);
        }else{
            return R.error().errorMsg("删除失败!").success(false);
        }
    }
    //删除用户购物车（删除单个）
    @DeleteMapping("/delShopCar/{id}")
    public R delShopCar(@PathVariable int id){
        boolean flags=productService.delShopCar(id);
        if(flags){
            return R.ok().errorMsg("删除成功!").success(true);
        }else{
            return R.error().errorMsg("删除失败!").success(false);
        }
    }

    /*
     * 新增购物车
     * （用户ID（userId）,商品ID（id）,数量(quantity),规格(modelDetails),单价(price)）
     * */
    @PostMapping("/addShopCar")
    public R addShopCar(@RequestBody Product p){
        int num=productService.addShopCar(p);
        if(num>0){
            return R.ok().errorMsg("添加购物车成功!").success(true);
        }else{
            return R.error().errorMsg("添加购物车失败!").success(false);
        }
    }

    @PutMapping("updateShopCar/{quantity}/{id}")
    public R updateShopCar(@PathVariable int quantity,@PathVariable int id){
        int num=productService.updateShopCar(quantity,id);
        if(num>0){
            return R.ok().errorMsg("购物车修改成功!").success(true);
        }else{
            return R.error().errorMsg("购物车修改失败!").success(false);
        }
    }

}
